
import {
    BASE_URL
} from '../../../http/config';
var WxParse = require('../../../wxParse/wxParse.js');

Page({
    /**
     * 页面的初始数据
     */
    data: {
        articleDetail: {}, // 文章详情数据
        detail: {}, // WxParse解析后的数据
        img: BASE_URL
    },

    /**
     * 获取文章详情
     * @param {number} articleId - 文章ID
     */
    getArticleDetail(articleId) {
        wx.showLoading({
            title: '数据正在加载...',
        });

        const _this = this;
        wx.request({
            url: `${BASE_URL}/article/findById/${articleId}`,
            method: 'GET',
            success: (res) => {
                console.log("文章详情数据：", res.data);

                if (res.data.code === 200) {
                    const result = res.data.data;

                    // 保存文章详情数据
                    _this.setData({
                        articleDetail: result
                    });

                    // 解析HTML内容（假设富文本字段为content）
                    if (result.content) {
                        try {
                            WxParse.wxParse('detail', 'html', result.content, _this, 5);
                            console.log("WxParse解析成功");
                        } catch (error) {
                            console.error("WxParse解析失败：", error);
                            // 如果WxParse失败，使用rich-text作为备选
                            _this.setData({
                                detail: {
                                    nodes: []
                                }
                            });
                        }
                    } else {
                        console.log("没有富文本内容");
                        _this.setData({
                            detail: {
                                nodes: []
                            }
                        });
                    }
                } else {
                    wx.showToast({
                        title: res.data.message || '获取详情失败',
                        icon: 'none'
                    });
                }
            },
            fail: (err) => {
                console.error("获取详情失败：", err);
                wx.showToast({
                    title: '网络错误，加载失败',
                    icon: 'none'
                });
            },
            complete: () => {
                wx.hideLoading(); // 无论成功失败都关闭加载
            }
        });
    },

    /**
     * 初始化阅读缓存
     */
    initReadCache() {
        try {
            let readCache = wx.getStorageSync('readCache');

            // 检查缓存是否有效，无效则初始化
            if (typeof readCache !== 'object' || readCache === null || Array.isArray(readCache)) {
                console.warn('缓存格式无效，初始化新缓存');
                readCache = {};
                wx.setStorageSync('readCache', readCache);
            }

            return readCache;
        } catch (error) {
            console.error('初始化缓存失败：', error);
            const emptyCache = {};
            wx.setStorageSync('readCache', emptyCache);
            return emptyCache;
        }
    },

    /**
     * 清理错误的缓存数据
     * @param {object} cache - 原始缓存对象
     * @returns {object} 清理后的缓存对象
     */
    cleanInvalidCacheData(cache) {
        const cleanedCache = {};

        // 遍历缓存，只保留有效数字值
        for (const key in cache) {
            const value = cache[key];
            // 尝试将值转换为数字
            const numericValue = parseInt(value, 10);
            if (!isNaN(numericValue)) {
                cleanedCache[key] = numericValue;
            } else {
                console.warn(`清理无效缓存数据：key=${key}, value=${value}`);
            }
        }

        return cleanedCache;
    },

    /**
     * 生命周期函数--监听页面加载
     */
    onLoad(options) {
        const articleId = options.id;
        console.log('传入的文章ID为：', articleId);

        if (articleId) {
            this.getArticleDetail(articleId);

            // 每次进入详情页面阅读量+1（缓存中）
            try {
                // 初始化并清理缓存
                let readCache = this.initReadCache();
                readCache = this.cleanInvalidCacheData(readCache);

                // 确保计数是数字类型
                const currentCount = Number(readCache[articleId]) || 0;
                readCache[articleId] = currentCount + 1; // 使用Number确保是数字相加而非字符串拼接

                wx.setStorageSync('readCache', readCache); // 更新缓存
                console.log('更新后的阅读缓存：', readCache);
            } catch (error) {
                console.error('处理阅读缓存时出错：', error);
                // 出错时重置缓存，确保值是数字
                wx.setStorageSync('readCache', {
                    [articleId]: 1
                });
            }
        } else {
            wx.showToast({
                title: '缺少文章ID',
                icon: 'none'
            });
            setTimeout(() => {
                wx.navigateBack();
            }, 1500);
        }
    },

    submitReadData() {
        try {
            let readCache = this.initReadCache();
            readCache = this.cleanInvalidCacheData(readCache);

            const readList = [];

            for (let id in readCache) {
                // 确保count是数字
                const count = Number(readCache[id]) || 0;
                if (count > 0) {
                    readList.push({
                        id: parseInt(id, 10),
                        count: count
                    });
                }
            }

            if (readList.length === 0) return;

            wx.request({
                url: `${BASE_URL}/article/read/batch`,
                method: 'POST',
                data: readList,
                header: {
                    'content-type': 'application/json'
                },
                success(res) {
                    console.log('阅读量上报成功', res);
                    if (res.data.code === 200) {
                        wx.removeStorageSync('readCache'); // 成功后清除缓存
                    }
                },
                fail(err) {
                    console.error('阅读量上报失败', err);
                }
            });
        } catch (error) {
            console.error('提交阅读数据时出错：', error);
        }
    },

    /**
     * 其他生命周期函数保持默认
     */
    onReady() {},
    onShow() {
        this.reportTimer = setInterval(() => {
            this.submitReadData();
        }, 30000); // 30秒上报一次
    },
    onHide() {
        clearInterval(this.reportTimer);
        this.submitReadData();
    },

    onUnload() {
        clearInterval(this.reportTimer);
        this.submitReadData();
    },
    onPullDownRefresh() {},
    onReachBottom() {},
    onShareAppMessage() {
        return {
            title: this.data.articleDetail.articleName || '文章详情',
            path: `/index/pages/articleDetail/articleDetail?id=${this.data.articleDetail.id}`
        };
    }
});
